"""主窗口界面"""

import tkinter as tk
from tkinter import ttk, messagebox
import asyncio
from typing import List, Optional
from pathlib import Path
import threading

from ..models.config import Config
from ..models.file_info import FileInfo
from ..models.directory_rule import AnalysisContext
from ..core.workspace_manager import WorkspaceManager
from ..core.ai_analyzer import AIAnalyzer
from ..utils.database import Database
from ..utils.logger import get_logger
from .components.drag_drop import DragDropFrame


class MainWindow:
    """主窗口类"""
    
    def __init__(self, root: tk.Tk, config: Config, database: Database, async_loop):
        """初始化主窗口"""
        self.root = root
        self.config = config
        self.database = database
        self.async_loop = async_loop
        self.logger = get_logger()
        
        # 初始化管理器
        self.workspace_manager = WorkspaceManager(database)
        self.ai_analyzer = AIAnalyzer(
            config.llm,
            config.user_preferences,
            database
        )
        
        # UI状态
        self.current_files: List[FileInfo] = []
        self.pending_rules = []
        
        # 创建UI
        self._create_ui()
        self._load_workspaces()
        
        self.logger.info("主窗口初始化完成")
    
    def _create_ui(self) -> None:
        """创建用户界面"""
        # 主框架
        self.main_frame = ttk.Frame(self.root)
        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 创建菜单栏
        self._create_menu()
        
        # 顶部工具栏
        self._create_toolbar()
        
        # 主内容区域
        self._create_content_area()
        
        # 底部状态栏
        self._create_status_bar()
    
    def _create_menu(self) -> None:
        """创建菜单栏"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)
        
        # 文件菜单
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="文件", menu=file_menu)
        file_menu.add_command(label="新建工作空间", command=self._new_workspace)
        file_menu.add_command(label="打开工作空间", command=self._open_workspace)
        file_menu.add_separator()
        file_menu.add_command(label="退出", command=self.root.quit)
        
        # 工具菜单
        tools_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="工具", menu=tools_menu)
        tools_menu.add_command(label="重新扫描目录", command=self._rescan_directory)
        tools_menu.add_command(label="清理缓存", command=self._clear_cache)
        
        # 设置菜单
        settings_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="设置", menu=settings_menu)
        settings_menu.add_command(label="偏好设置", command=self._show_preferences)
        settings_menu.add_command(label="大模型配置", command=self._show_llm_config)
        
        # 帮助菜单
        help_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="帮助", menu=help_menu)
        help_menu.add_command(label="使用指南", command=self._show_help)
        help_menu.add_command(label="关于", command=self._show_about)
    
    def _create_toolbar(self) -> None:
        """创建工具栏"""
        toolbar_frame = ttk.Frame(self.main_frame)
        toolbar_frame.pack(fill=tk.X, pady=(0, 10))
        
        # 工作空间选择
        ttk.Label(toolbar_frame, text="当前工作空间:").pack(side=tk.LEFT, padx=(0, 5))
        
        self.workspace_var = tk.StringVar()
        self.workspace_combo = ttk.Combobox(
            toolbar_frame,
            textvariable=self.workspace_var,
            width=30,
            state="readonly"
        )
        self.workspace_combo.pack(side=tk.LEFT, padx=(0, 10))
        self.workspace_combo.bind('<<ComboboxSelected>>', self._on_workspace_changed)
        
        # 工具按钮
        ttk.Button(
            toolbar_frame,
            text="新建工作空间",
            command=self._new_workspace
        ).pack(side=tk.LEFT, padx=(0, 5))
        
        ttk.Button(
            toolbar_frame,
            text="管理工作空间",
            command=self._manage_workspaces
        ).pack(side=tk.LEFT, padx=(0, 5))
        
        # 右侧按钮
        ttk.Button(
            toolbar_frame,
            text="历史记录",
            command=self._show_history
        ).pack(side=tk.RIGHT, padx=(5, 0))
        
        ttk.Button(
            toolbar_frame,
            text="设置",
            command=self._show_preferences
        ).pack(side=tk.RIGHT, padx=(5, 0))
    
    def _create_content_area(self) -> None:
        """创建主内容区域"""
        # 使用PanedWindow分割界面
        paned = ttk.PanedWindow(self.main_frame, orient=tk.HORIZONTAL)
        paned.pack(fill=tk.BOTH, expand=True)
        
        # 左侧：拖放区域和文件列表
        left_frame = ttk.Frame(paned)
        paned.add(left_frame, weight=2)
        
        # 拖放区域
        self.drag_drop_frame = DragDropFrame(
            left_frame,
            drop_callback=self._on_files_dropped
        )
        self.drag_drop_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
        
        # 用户描述输入
        desc_frame = ttk.LabelFrame(left_frame, text="文件描述（可选）")
        desc_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.description_text = tk.Text(desc_frame, height=3, wrap=tk.WORD)
        self.description_text.pack(fill=tk.X, padx=5, pady=5)
        
        # 分析按钮
        button_frame = ttk.Frame(left_frame)
        button_frame.pack(fill=tk.X)
        
        self.analyze_button = ttk.Button(
            button_frame,
            text="智能分析",
            command=self._analyze_files,
            state=tk.DISABLED
        )
        self.analyze_button.pack(side=tk.LEFT, padx=(0, 5))
        
        ttk.Button(
            button_frame,
            text="清空文件",
            command=self._clear_files
        ).pack(side=tk.LEFT)
        
        # 右侧：分析结果和预览
        right_frame = ttk.Frame(paned)
        paned.add(right_frame, weight=3)
        
        # 分析结果
        result_frame = ttk.LabelFrame(right_frame, text="归档建议")
        result_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
        
        # 创建Treeview显示结果
        columns = ('文件名', '建议路径', '置信度', '分类')
        self.result_tree = ttk.Treeview(result_frame, columns=columns, show='headings')
        
        for col in columns:
            self.result_tree.heading(col, text=col)
            self.result_tree.column(col, width=150)
        
        # 滚动条
        scrollbar = ttk.Scrollbar(result_frame, orient=tk.VERTICAL, command=self.result_tree.yview)
        self.result_tree.configure(yscrollcommand=scrollbar.set)
        
        self.result_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # 操作按钮
        action_frame = ttk.Frame(right_frame)
        action_frame.pack(fill=tk.X)
        
        self.execute_button = ttk.Button(
            action_frame,
            text="执行归档",
            command=self._execute_archiving,
            state=tk.DISABLED
        )
        self.execute_button.pack(side=tk.LEFT, padx=(0, 5))
        
        ttk.Button(
            action_frame,
            text="修改建议",
            command=self._modify_suggestions
        ).pack(side=tk.LEFT, padx=(0, 5))
        
        ttk.Button(
            action_frame,
            text="预览结构",
            command=self._preview_structure
        ).pack(side=tk.LEFT)
    
    def _create_status_bar(self) -> None:
        """创建状态栏"""
        self.status_frame = ttk.Frame(self.main_frame)
        self.status_frame.pack(fill=tk.X, pady=(10, 0))
        
        self.status_label = ttk.Label(self.status_frame, text="就绪")
        self.status_label.pack(side=tk.LEFT)
        
        # 进度条
        self.progress = ttk.Progressbar(
            self.status_frame,
            mode='indeterminate',
            length=200
        )
        self.progress.pack(side=tk.RIGHT, padx=(10, 0))
    
    def _load_workspaces(self) -> None:
        """加载工作空间列表"""
        workspaces = self.workspace_manager.list_workspaces()
        workspace_names = [f"{ws.name} ({ws.root_path})" for ws in workspaces]
        
        self.workspace_combo['values'] = workspace_names
        
        if workspaces:
            self.workspace_combo.current(0)
            self._on_workspace_changed()
        else:
            self._show_workspace_setup()
    
    def _show_workspace_setup(self) -> None:
        """显示工作空间设置向导"""
        result = messagebox.askyesno(
            "欢迎使用文件归纳所",
            "看起来这是您第一次使用本应用。\\n是否要创建第一个工作空间？"
        )
        
        if result:
            self._new_workspace()
    
    def _on_workspace_changed(self, event=None) -> None:
        """工作空间切换事件"""
        selection = self.workspace_combo.current()
        if selection >= 0:
            workspaces = self.workspace_manager.list_workspaces()
            if selection < len(workspaces):
                workspace = workspaces[selection]
                self.workspace_manager.switch_workspace(workspace.id)
                self._update_status(f"已切换到工作空间: {workspace.name}")
    
    def _on_files_dropped(self, file_paths: List[str]) -> None:
        """文件拖放处理"""
        try:
            self.current_files = []
            
            for file_path in file_paths:
                try:
                    file_info = FileInfo.from_path(Path(file_path))
                    self.current_files.append(file_info)
                except Exception as e:
                    self.logger.warning(f"无法处理文件 {file_path}: {e}")
            
            if self.current_files:
                self._update_status(f"已添加 {len(self.current_files)} 个文件")
                self.analyze_button.config(state=tk.NORMAL)
                
                # 自动分析（如果设置了自动分析）
                if self.config.user_preferences.auto_confirm:
                    self._analyze_files()
            else:
                messagebox.showwarning("警告", "没有找到有效的文件")
                
        except Exception as e:
            self.logger.error(f"文件处理失败: {e}")
            messagebox.showerror("错误", f"文件处理失败：\\n{e}")
    
    def _analyze_files(self) -> None:
        """分析文件"""
        if not self.current_files:
            messagebox.showwarning("提示", "请先添加要分析的文件")
            return
        
        current_workspace = self.workspace_manager.get_current_workspace()
        if not current_workspace:
            messagebox.showwarning("提示", "请先选择或创建工作空间")
            return
        
        # 获取用户描述
        user_description = self.description_text.get(1.0, tk.END).strip()
        
        # 构建分析上下文
        context = AnalysisContext(
            existing_structure=self.workspace_manager.get_directory_structure(current_workspace.id),
            user_description=user_description if user_description else None,
            user_preferences=self.config.user_preferences.dict(),
            workspace_id=current_workspace.id
        )
        
        # 异步分析
        self._run_async_analysis(context)
    
    def _run_async_analysis(self, context: AnalysisContext) -> None:
        """运行异步分析"""
        def run_analysis():
            try:
                # 显示进度
                self.root.after(0, self._show_progress, "正在分析文件...")
                
                # 在异步循环中运行分析
                future = asyncio.run_coroutine_threadsafe(
                    self.ai_analyzer.analyze_files(self.current_files, context),
                    self.async_loop
                )
                
                # 等待结果
                rules = future.result(timeout=60)  # 60秒超时
                
                # 更新UI
                self.root.after(0, self._on_analysis_complete, rules)
                
            except Exception as e:
                self.root.after(0, self._on_analysis_error, str(e))
        
        # 在后台线程中运行
        thread = threading.Thread(target=run_analysis, daemon=True)
        thread.start()
    
    def _on_analysis_complete(self, rules) -> None:
        """分析完成回调"""
        self._hide_progress()
        self.pending_rules = rules
        self._display_analysis_results(rules)
        self._update_status(f"分析完成，生成了 {len(rules)} 个归档建议")
    
    def _on_analysis_error(self, error: str) -> None:
        """分析错误回调"""
        self._hide_progress()
        self.logger.error(f"文件分析失败: {error}")
        messagebox.showerror("分析失败", f"文件分析失败：\\n{error}")
    
    def _display_analysis_results(self, rules) -> None:
        """显示分析结果"""
        # 清空现有结果
        for item in self.result_tree.get_children():
            self.result_tree.delete(item)
        
        # 添加新结果
        for i, (file_info, rule) in enumerate(zip(self.current_files, rules)):
            confidence_text = f"{rule.confidence:.1%}"
            
            self.result_tree.insert('', 'end', values=(
                file_info.name,
                str(rule.suggested_path),
                confidence_text,
                rule.category
            ))
        
        # 启用执行按钮
        self.execute_button.config(state=tk.NORMAL)
    
    def _execute_archiving(self) -> None:
        """执行归档操作"""
        if not self.pending_rules:
            messagebox.showwarning("提示", "没有可执行的归档建议")
            return
        
        # 确认对话框
        result = messagebox.askyesno(
            "确认归档",
            f"确定要执行归档操作吗？\\n这将移动 {len(self.pending_rules)} 个文件。"
        )
        
        if result:
            self._perform_archiving()
    
    def _perform_archiving(self) -> None:
        """执行实际的归档操作"""
        # TODO: 实现文件移动逻辑
        messagebox.showinfo("提示", "归档功能正在开发中...")
    
    def _show_progress(self, text: str) -> None:
        """显示进度"""
        self._update_status(text)
        self.progress.start()
        self.analyze_button.config(state=tk.DISABLED)
    
    def _hide_progress(self) -> None:
        """隐藏进度"""
        self.progress.stop()
        self.analyze_button.config(state=tk.NORMAL)
    
    def _update_status(self, text: str) -> None:
        """更新状态栏"""
        self.status_label.config(text=text)
    
    def _clear_files(self) -> None:
        """清空文件列表"""
        self.current_files = []
        self.pending_rules = []
        self.analyze_button.config(state=tk.DISABLED)
        self.execute_button.config(state=tk.DISABLED)
        self.description_text.delete(1.0, tk.END)
        
        # 清空结果
        for item in self.result_tree.get_children():
            self.result_tree.delete(item)
        
        self._update_status("已清空文件列表")
    
    # 菜单命令方法
    def _new_workspace(self) -> None:
        """新建工作空间"""
        # TODO: 实现工作空间创建对话框
        messagebox.showinfo("提示", "新建工作空间功能正在开发中...")
    
    def _open_workspace(self) -> None:
        """打开工作空间"""
        # TODO: 实现工作空间打开对话框
        messagebox.showinfo("提示", "打开工作空间功能正在开发中...")
    
    def _manage_workspaces(self) -> None:
        """管理工作空间"""
        # TODO: 实现工作空间管理界面
        messagebox.showinfo("提示", "工作空间管理功能正在开发中...")
    
    def _rescan_directory(self) -> None:
        """重新扫描目录"""
        current_workspace = self.workspace_manager.get_current_workspace()
        if current_workspace:
            self.workspace_manager.rescan_workspace(current_workspace.id)
            self._update_status("目录重新扫描完成")
        else:
            messagebox.showwarning("提示", "请先选择工作空间")
    
    def _clear_cache(self) -> None:
        """清理缓存"""
        self.database.cleanup_expired_cache()
        self._update_status("缓存清理完成")
    
    def _show_preferences(self) -> None:
        """显示偏好设置"""
        # TODO: 实现偏好设置界面
        messagebox.showinfo("提示", "偏好设置功能正在开发中...")
    
    def _show_llm_config(self) -> None:
        """显示大模型配置"""
        # TODO: 实现LLM配置界面
        messagebox.showinfo("提示", "大模型配置功能正在开发中...")
    
    def _show_history(self) -> None:
        """显示历史记录"""
        # TODO: 实现历史记录界面
        messagebox.showinfo("提示", "历史记录功能正在开发中...")
    
    def _modify_suggestions(self) -> None:
        """修改建议"""
        # TODO: 实现建议修改界面
        messagebox.showinfo("提示", "修改建议功能正在开发中...")
    
    def _preview_structure(self) -> None:
        """预览目录结构"""
        # TODO: 实现目录结构预览
        messagebox.showinfo("提示", "目录结构预览功能正在开发中...")
    
    def _show_help(self) -> None:
        """显示帮助"""
        help_text = """文件归纳所 - 使用指南
        
1. 创建或选择工作空间
2. 将文件拖放到左侧区域
3. 可选：添加文件描述
4. 点击"智能分析"获取归档建议
5. 确认后点击"执行归档"
        
如需更多帮助，请查看用户手册。"""
        
        messagebox.showinfo("使用指南", help_text)
    
    def _show_about(self) -> None:
        """显示关于信息"""
        about_text = f"""文件归纳所 v{self.config.app.app_version}

基于大模型的智能文件管理工具

开发团队: File Organizer Team
技术支持: AI驱动的智能分析"""
        
        messagebox.showinfo("关于", about_text)